LARKTM: Efficient, Strongly Atomic Software Transactional Memory

Software transactional memory provides an appealing alternative to locks by improving programmability, reliability, and scalability without relying on custom hardware. However, existing STMs are impractical because they add high overhead and provide weak semantics—or they provide strong atomicity semantics and add even higher overhead. Existing STMs are impractical largely due to the cost of concurrency control, which requires synchronization at essentially every transactional memory access—or every memory access in the case of strongly atomic STM. Most STMs avoid these synchronization costs through techniques such as lazy conflict detection and privatization support, but these techniques add their own overheads, still incur significant synchronization costs, provide weak semantics, and result in impractical systems. This paper introduces a novel, strongly atomic STM called LARKTM that resembles many hardware TM designs: it uses eager versioning, conflict detection, and conflict resolution, and it provides strong atomicity. However, LARKTM avoids high software overhead from these features by using an efficient, optimistic concurrency control mechanism that avoids synchronization except for truly conflicting memory accesses. Overall overhead and scalability results for a prototype implementation are mixed, but they suggest that LARKTM’s approach offers a promising new direction for providing practical strongly atomic STM on commodity systems.